﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Rapattern.Utility;

namespace Rapattern.Matrix
{
    /// <summary>
    /// 字模转换帮助类
    /// </summary>
    public class MatrixHelper
    {
        /// <summary>
        /// 16×16汉字点阵 字模转换
        /// </summary>
        /// <param name="source">要转换的字节数组</param>
        /// <param name="inType">转换前字模类型</param>
        /// <param name="outType">转换后的字模类型</param>
        /// <param name="defaultValue">设置返回默认值</param>
        /// <returns>错误时返回默认值null</returns>
        public static byte[] ConvertMatrix(byte[] source, MatrixType inType, MatrixType outType, byte[] defaultValue = null)
        {
            if (source == null || source.Length != 32)
                return defaultValue;
            if (inType == outType)
                return source.Clone() as byte[];

            byte[] result = null;

            if (inType == MatrixType.ColPositive)
            {
                result = ColPositiveMatrix(source as byte[], outType);
            }
            else if (inType == MatrixType.ColAntitone)
            {
                result = ColAntitoneMatrix(source as byte[], outType);
            }
            else if (inType == MatrixType.RowPositive)
            {
                result = RowPositiveMatrix(source as byte[], outType);
            }
            else if (inType == MatrixType.RowAntitone)
            {
                result = RowAntitoneMatrix(source as byte[], outType);
            }
            return result;
        }

        /// <summary>
        /// 横向正序字模转换
        /// </summary>
        /// <param name="source"></param>
        /// <param name="outType"></param>
        /// <returns></returns>
        private static byte[] ColPositiveMatrix(byte[] source, MatrixType outType)
        {
            byte[] result = new byte[32];
            if (outType == MatrixType.ColAntitone)
            {
                // 转换成横向倒序
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray oldAry = new BitArray(new byte[] { source[i] });
                    BitArray newAry = new BitArray(8);
                    for (int j = 0; j < newAry.Length; j++)
                    {
                        newAry[j] = oldAry[7 - j];
                    }
                    result[i] = ConvertHelper.BitArrayConvertByte(newAry);
                }
            }
            else if (outType == MatrixType.RowPositive)
            {
                // 转换成纵向正序
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray newAry = new BitArray(8);
                    for (int j = 0; j < newAry.Length; j++)
                    {
                        int oIndex = 7, tIndex = j * 2;
                        if (i < 8)
                        {
                            oIndex = 7 - i;
                        }
                        else if (i > 15 && i < 24)
                        {
                            oIndex = 23 - i;
                            tIndex += 16;
                        }
                        else if (i >= 8 && i <= 15)
                        {
                            oIndex = 15 - i;
                            tIndex += 1;
                        }
                        else if (i >= 24)
                        {
                            oIndex = 31 - i;
                            tIndex += (1 + 16);
                        }
                        BitArray oldAry = new BitArray(new byte[] { source[tIndex] });

                        newAry.Set(7 - j, oldAry[oIndex]);
                    }
                    result[i] = ConvertHelper.BitArrayConvertByte(newAry);
                }
            }
            else if (outType == MatrixType.RowAntitone)
            {
                // 转换成纵向倒序
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray newAry = new BitArray(8);
                    for (int j = 0; j < newAry.Length; j++)
                    {
                        int oIndex = 7, tIndex = j * 2;
                        if (i < 8)
                        {
                            oIndex = 7 - i;
                        }
                        else if (i > 15 && i < 24)
                        {
                            oIndex = 23 - i;
                            tIndex += 16;
                        }
                        else if (i >= 8 && i <= 15)
                        {
                            oIndex = 15 - i;
                            tIndex += 1;
                        }
                        else if (i >= 24)
                        {
                            oIndex = 31 - i;
                            tIndex += (1 + 16);
                        }
                        BitArray oldAry = new BitArray(new byte[] { source[tIndex] });

                        newAry.Set(j, oldAry[oIndex]);
                    }
                    result[i] = ConvertHelper.BitArrayConvertByte(newAry);
                }
            }
            else
            {
                throw new Exception("无法确定转化目标模型");
            }

            return result;
        }

        /// <summary>
        /// 横向倒序字模转换
        /// </summary>
        /// <param name="source"></param>
        /// <param name="outType"></param>
        /// <returns></returns>
        private static byte[] ColAntitoneMatrix(byte[] source, MatrixType outType)
        {
            byte[] result = new byte[32];
            if (outType == MatrixType.ColPositive)
            {
                // 转换成横向正序
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray oldAry = new BitArray(new byte[] { source[i] });
                    BitArray newAry = new BitArray(8);
                    for (int j = 0; j < newAry.Length; j++)
                    {
                        newAry[j] = oldAry[7 - j];
                    }
                    result[i] = ConvertHelper.BitArrayConvertByte(newAry);
                }
            }
            else if (outType == MatrixType.RowPositive)
            {
                // 转换成纵向正序
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray newAry = new BitArray(8);
                    for (int j = 0; j < newAry.Length; j++)
                    {
                        int oIndex = 7, tIndex = j * 2;
                        if (i < 8)
                        {
                            oIndex = 7 - i;
                        }
                        else if (i > 15 && i < 24)
                        {
                            oIndex = 23 - i;
                            tIndex += 16;
                        }
                        else if (i >= 8 && i <= 15)
                        {
                            oIndex = 15 - i;
                            tIndex += 1;
                        }
                        else if (i >= 24)
                        {
                            oIndex = 31 - i;
                            tIndex += (1 + 16);
                        }
                        BitArray oldAry = new BitArray(new byte[] { source[tIndex] });

                        newAry.Set(7 - j, oldAry[7 - oIndex]);
                    }
                    result[i] = ConvertHelper.BitArrayConvertByte(newAry);
                }
            }
            else if (outType == MatrixType.RowAntitone)
            {
                // 转换成纵向倒序
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray newAry = new BitArray(8);
                    for (int j = 0; j < newAry.Length; j++)
                    {
                        int oIndex = 7, tIndex = j * 2;
                        if (i < 8)
                        {
                            oIndex = 7 - i;
                        }
                        else if (i > 15 && i < 24)
                        {
                            oIndex = 23 - i;
                            tIndex += 16;
                        }
                        else if (i >= 8 && i <= 15)
                        {
                            oIndex = 15 - i;
                            tIndex += 1;
                        }
                        else if (i >= 24)
                        {
                            oIndex = 31 - i;
                            tIndex += (1 + 16);
                        }
                        BitArray oldAry = new BitArray(new byte[] { source[tIndex] });

                        newAry.Set(j, oldAry[7 - oIndex]);
                    }
                    result[i] = ConvertHelper.BitArrayConvertByte(newAry);
                }
            }
            else
            {
                throw new Exception("无法确定转化目标模型");
            }

            return result;
        }

        /// <summary>
        /// 纵向正序字模转换
        /// </summary>
        /// <param name="source"></param>
        /// <param name="outType"></param>
        /// <returns></returns>
        private static byte[] RowPositiveMatrix(byte[] source, MatrixType outType)
        {
            byte[] result = new byte[32];

            if (outType == MatrixType.ColPositive)
            {
                // 转换成横向正序
                BitArray bitArray = new BitArray(256);
                int oIndex = 7;
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray oldAry = new BitArray(new byte[] { source[i] });
                    for (int j = 0; j < oldAry.Length; j++)
                    {
                        int tIndex = j * 16;
                        if (i > 7 && i < 16)
                        {
                            tIndex += 8;
                        }
                        else if (i >= 16 && i < 24)
                        {
                            tIndex += (16 * 8);
                        }
                        else if(i>=24)
                        {
                            tIndex += (16 * 8 + 8);
                        }
                        bitArray.Set(tIndex + oIndex, oldAry[7 - j]);
                    }
                    oIndex--;
                    if (oIndex < 0)
                        oIndex = 7;
                }
                result = Rapattern.Utility.ConvertHelper.BitArrayConvertBytes(bitArray);
            }
            else if (outType == MatrixType.ColAntitone)
            {
                // 转换成横向倒序
                BitArray bitArray = new BitArray(256);
                int oIndex = 0;
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray oldAry = new BitArray(new byte[] { source[i] });
                    for (int j = 0; j < oldAry.Length; j++)
                    {
                        int tIndex = j * 16;
                        if (i > 7 && i < 16)
                        {
                            tIndex += 8;
                        }
                        else if (i >= 16 && i < 24)
                        {
                            tIndex += (16 * 8);
                        }
                        else if (i >= 24)
                        {
                            tIndex += (16 * 8 + 8);
                        }
                        bitArray.Set(tIndex + oIndex, oldAry[7-j]);
                    }
                    oIndex++;
                    if (oIndex > 7)
                        oIndex = 0;
                }
                result = Rapattern.Utility.ConvertHelper.BitArrayConvertBytes(bitArray);
            }
            else if (outType == MatrixType.RowAntitone)
            {
                // 转换成纵向倒序
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray oldAry = new BitArray(new byte[] { source[i] });
                    BitArray newAry = new BitArray(8);
                    for (int j = 0; j < newAry.Length; j++)
                    {
                        newAry[j] = oldAry[7 - j];
                    }
                    result[i] = ConvertHelper.BitArrayConvertByte(newAry);
                }
            }
            else
            {
                throw new Exception("无法确定转化目标模型");
            }

            return result;
        }

        /// <summary>
        /// 纵向倒序字模转换
        /// </summary>
        /// <param name="source"></param>
        /// <param name="outType"></param>
        /// <returns></returns>
        private static byte[] RowAntitoneMatrix(byte[] source, MatrixType outType)
        {
            byte[] result = new byte[32];
            if (outType == MatrixType.ColPositive)
            {
                // 转换成横向正序
                BitArray bitArray = new BitArray(256);
                int oIndex = 7;
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray oldAry = new BitArray(new byte[] { source[i] });
                    for (int j = 0; j < oldAry.Length; j++)
                    {
                        int tIndex = j * 16;
                        if (i > 7 && i < 16)
                        {
                            tIndex += 8;
                        }
                        else if (i >= 16 && i < 24)
                        {
                            tIndex += (16 * 8);
                        }
                        else if (i >= 24)
                        {
                            tIndex += (16 * 8 + 8);
                        }
                        bitArray.Set(tIndex + oIndex, oldAry[j]);
                    }
                    oIndex--;
                    if (oIndex < 0)
                        oIndex = 7;
                }
                result = Rapattern.Utility.ConvertHelper.BitArrayConvertBytes(bitArray);
            }
            else if (outType == MatrixType.ColAntitone)
            {
                // 转换成横向倒序
                BitArray bitArray = new BitArray(256);
                int oIndex = 0;
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray oldAry = new BitArray(new byte[] { source[i] });
                    for (int j = 0; j < oldAry.Length; j++)
                    {
                        int tIndex = j * 16;
                        if (i > 7 && i < 16)
                        {
                            tIndex += 8;
                        }
                        else if (i >= 16 && i < 24)
                        {
                            tIndex += (16 * 8);
                        }
                        else if (i >= 24)
                        {
                            tIndex += (16 * 8 + 8);
                        }
                        bitArray.Set(tIndex + oIndex, oldAry[j]);
                    }
                    oIndex++;
                    if (oIndex > 7)
                        oIndex = 0;
                }
                result = Rapattern.Utility.ConvertHelper.BitArrayConvertBytes(bitArray);
            }
            else if (outType == MatrixType.RowPositive)
            {
                // 转换成纵向正序
                for (int i = 0; i < result.Length; i++)
                {
                    BitArray oldAry = new BitArray(new byte[] { source[i] });
                    BitArray newAry = new BitArray(8);
                    for (int j = 0; j < newAry.Length; j++)
                    {
                        newAry[j] = oldAry[7 - j];
                    }
                    result[i] = ConvertHelper.BitArrayConvertByte(newAry);
                }
            }
            else
            {
                throw new Exception("无法确定转化目标模型");
            }

            return result;
        }
    }
}
